package com.springboot.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.springboot.common.Result;
import com.springboot.entity.Cart;
import com.springboot.entity.Product;
import com.springboot.entity.ProductSku;
import com.springboot.mapper.CartMapper;
import com.springboot.service.ICartService;
import com.springboot.service.IProductService;
import com.springboot.service.IProductSkuService;
import com.springboot.utils.IntegerUtils;
import com.springboot.vo.CartItemVO;
import com.springboot.vo.CartVO;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;

/**
 * 购物车表 服务实现类
 *
 * @author zjb
 * @since 2025-10-30
 */
@Service
public class CartServiceImpl extends ServiceImpl<CartMapper, Cart> implements ICartService {

    @Resource
    private CartMapper cartMapper;

    @Resource
    private IProductService productService;

    @Resource
    private IProductSkuService productSkuService;

    /**
     * 添加商品到购物车
     *
     * @param userId    用户ID
     * @param productId 商品ID
     * @param skuId     SKU ID（可为空）
     * @param quantity  数量
     * @return 添加结果
     */
    @Override
    public Result addToCart(Integer userId, Integer productId, Integer skuId, Integer quantity) {
        // 参数校验
        if (IntegerUtils.isEmptyOrZero(productId)) {
            return Result.error("商品ID不能为空");
        }

        if (quantity == null || quantity <= 0) {
            return Result.error("商品数量必须大于0");
        }

        // 检查商品是否存在
        Product product = productService.getById(productId);
        if (product == null) {
            return Result.error("商品不存在");
        }

        // 检查SKU是否存在（如果提供了skuId）
        if (skuId != null && skuId > 0) {
            ProductSku sku = productSkuService.getById(skuId);
            if (sku == null) {
                return Result.error("商品规格不存在");
            }

            if (!productId.equals(sku.getProductId())) {
                return Result.error("商品与规格不匹配");
            }
        }

        // 检查购物车中是否已存在相同的商品和规格
        LambdaQueryWrapper<Cart> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Cart::getUserId, userId)
                .eq(Cart::getProductId, productId)
                .eq(Cart::getSkuId, skuId);
        Cart existingCart = getOne(queryWrapper);

        if (existingCart != null) {
            // 如果已存在，增加数量
            existingCart.setQuantity(existingCart.getQuantity() + quantity);
            existingCart.setUpdateTime(LocalDateTime.now());
            updateById(existingCart);
        } else {
            // 如果不存在，新增购物车项
            Cart cart = new Cart();
            cart.setUserId(userId);
            cart.setProductId(productId);
            cart.setSkuId(skuId);
            cart.setQuantity(quantity);
            cart.setChecked(1); // 默认选中
            cart.setCreateTime(LocalDateTime.now());
            cart.setUpdateTime(LocalDateTime.now());
            save(cart);
        }

        return Result.success("添加成功");
    }

    /**
     * 获取用户购物车
     *
     * @param userId 用户ID
     * @return 购物车信息
     */
    @Override
    public Result getCart(Integer userId) {
        // 查询购物车项
        List<CartItemVO> cartItems = cartMapper.selectCartByUserId(userId);
        System.out.println(cartItems);
        // 计算选中商品的数量和总价
        int selectedCount = 0;
        BigDecimal selectedTotalPrice = BigDecimal.ZERO;

        if (!CollectionUtils.isEmpty(cartItems)) {
            for (CartItemVO item : cartItems) {
                if (Integer.valueOf(1).equals(item.getChecked())) {
                    selectedCount += item.getQuantity();
                    selectedTotalPrice = selectedTotalPrice.add(item.getSubtotal());
                }
            }
        }

        // 构造返回结果
        CartVO cartVO = new CartVO();
        cartVO.setCartItems(cartItems);
        cartVO.setSelectedCount(selectedCount);
        cartVO.setSelectedTotalPrice(selectedTotalPrice);
        System.out.println(cartVO);

        return Result.success(cartVO);
    }

    /**
     * 更新购物车项数量
     *
     * @param userId   用户ID
     * @param cartId   购物车项ID
     * @param quantity 数量
     * @return 更新结果
     */
    @Override
    public Result updateQuantity(Integer userId, Integer cartId, Integer quantity) {
        if (IntegerUtils.isEmptyOrZero(cartId)) {
            return Result.error("购物车项ID不能为空");
        }

        if (quantity == null || quantity <= 0) {
            return Result.error("商品数量必须大于0");
        }

        // 查找购物车项
        Cart cart = getById(cartId);
        if (cart == null) {
            return Result.error("购物车项不存在");
        }

        // 检查是否属于当前用户
        if (!userId.equals(cart.getUserId())) {
            return Result.error("无权限操作");
        }

        // 更新数量
        cart.setQuantity(quantity);
        cart.setUpdateTime(LocalDateTime.now());
        updateById(cart);

        return Result.success("更新成功");
    }

    /**
     * 删除购物车项
     *
     * @param userId 用户ID
     * @param cartId 购物车项ID
     * @return 删除结果
     */
    @Override
    public Result deleteCartItem(Integer userId, Integer cartId) {
        if (IntegerUtils.isEmptyOrZero(cartId)) {
            return Result.error("购物车项ID不能为空");
        }

        // 查找购物车项
        Cart cart = getById(cartId);
        if (cart == null) {
            return Result.error("购物车项不存在");
        }

        // 检查是否属于当前用户
        if (!userId.equals(cart.getUserId())) {
            return Result.error("无权限操作");
        }

        // 删除购物车项
        removeById(cartId);

        return Result.success("删除成功");
    }

    /**
     * 切换购物车项选中状态
     *
     * @param userId 用户ID
     * @param cartId 购物车项ID
     * @return 切换结果
     */
    @Override
    public Result toggleCheck(Integer userId, Integer cartId) {
        if (IntegerUtils.isEmptyOrZero(cartId)) {
            return Result.error("购物车项ID不能为空");
        }

        // 查找购物车项
        Cart cart = getById(cartId);
        if (cart == null) {
            return Result.error("购物车项不存在");
        }

        // 检查是否属于当前用户
        if (!userId.equals(cart.getUserId())) {
            return Result.error("无权限操作");
        }

        // 切换选中状态
        cart.setChecked(cart.getChecked() == 1 ? 0 : 1);
        cart.setUpdateTime(LocalDateTime.now());
        updateById(cart);

        return Result.success("操作成功");
    }

    /**
     * 批量切换购物车项选中状态
     *
     * @param userId  用户ID
     * @param cartIds 购物车项ID列表
     * @param checked 选中状态：1-选中，0-未选中
     * @return 切换结果
     */
    @Override
    public Result batchToggleCheck(Integer userId, Integer[] cartIds, Integer checked) {
        if (cartIds == null || cartIds.length == 0) {
            return Result.error("请选择要操作的购物车项");
        }

        if (checked == null || (checked != 0 && checked != 1)) {
            return Result.error("选中状态不正确");
        }

        // 批量更新选中状态
        for (Integer cartId : cartIds) {
            Cart cart = getById(cartId);
            if (cart != null && userId.equals(cart.getUserId())) {
                cart.setChecked(checked);
                cart.setUpdateTime(LocalDateTime.now());
                updateById(cart);
            }
        }

        return Result.success("操作成功");
    }

    /**
     * 清空用户购物车
     *
     * @param userId 用户ID
     * @return 清空结果
     */
    @Override
    public Result clearCart(Integer userId) {
        LambdaQueryWrapper<Cart> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Cart::getUserId, userId);
        remove(queryWrapper);

        return Result.success("购物车已清空");
    }
}